home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / tcpip / sys5 / iscwmpst.z / iscwmpst / tcp / src / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-04  |  10.5 KB  |  604 lines
  1. /* @(#) $Header: main.c,v 1.22 91/10/03 11:05:12 deyke Exp $ */
  2.  
  3. /* Main-level NOS program:
  4.  *  initialization
  5.  *  keyboard processing
  6.  *  generic user commands
  7.  *
  8.  * Copyright 1991 Phil Karn, KA9Q
  9.  */
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <time.h>
  13. #if     defined(__TURBOC__) && defined(MSDOS)
  14. #include <io.h>
  15. #include <conio.h>
  16. #endif
  17. #include <unistd.h>
  18. #include "global.h"
  19. #ifdef  ANSIPROTO
  20. #include <stdarg.h>
  21. #endif
  22. #include "mbuf.h"
  23. #include "timer.h"
  24. #include "proc.h"
  25. #include "iface.h"
  26. #include "ip.h"
  27. #include "tcp.h"
  28. #include "udp.h"
  29. #include "ax25.h"
  30. #include "kiss.h"
  31. #include "enet.h"
  32. #include "netrom.h"
  33. #include "ftp.h"
  34. #include "telnet.h"
  35. #include "tty.h"
  36. #include "session.h"
  37. #include "hardware.h"
  38. /* #include "usock.h" */
  39. #include "socket.h"
  40. #include "cmdparse.h"
  41. #include "commands.h"
  42. /* #include "daemon.h" */
  43. #include "devparam.h"
  44. /* #include "domain.h" */
  45. #include "files.h"
  46. #include "main.h"
  47. #include "remote.h"
  48. #include "trace.h"
  49. #include "hpux.h"
  50. #include "netuser.h"
  51. #include "remote_net.h"
  52.  
  53. extern int errno;
  54. extern char *sys_errlist[];
  55.  
  56. extern struct cmds Cmds[],Startcmds[],Stopcmds[],Attab[];
  57.  
  58. #ifndef MSDOS                   /* PC uses F-10 key always */
  59. char Escape = 0x1d;             /* default escape character is ^] */
  60. #endif
  61.  
  62. int Debug;
  63. int Mode;
  64. char Badhost[] = "Unknown host %s\n";
  65. char *Hostname;
  66. char Prompt[] = "%s> ";
  67. char Nospace[] = "No space!!\n";        /* Generic malloc fail message */
  68. static FILE *Logfp;
  69. int16 Lport = 1024;
  70. static int Verbose;
  71.  
  72. int
  73. main(argc,argv)
  74. int argc;
  75. char *argv[];
  76. {
  77.     static char linebuf[BUFSIZ];    /* keep it off the stack */
  78.     FILE *fp;
  79.     int c;
  80.  
  81.     Debug = (argc >= 2);
  82.  
  83.     while((c = getopt(argc,argv,"v")) != EOF){
  84.         switch(c){
  85.         case 'v':
  86.             Verbose = 1;
  87.             break;
  88.         }
  89.     }
  90.     ipinit();
  91.     ioinit();
  92.     netrom_initialize();
  93.     remote_net_initialize();
  94.  
  95.     Sessions = (struct session *)callocw(Nsessions,sizeof(struct session));
  96.     tprintf("\n================ %s ================\n", Version);
  97.     tprintf("(c) Copyright 1990, 1991 by Dieter Deyke, DK5SG\n");
  98.     tprintf("(c) Copyright 1990 by Phil Karn, KA9Q\n");
  99.     tprintf("\n");
  100.  
  101.     if(optind < argc){
  102.         /* Read startup file named on command line */
  103.         if((fp = fopen(argv[optind],READ_TEXT)) == NULLFILE)
  104.             tprintf("Can't read config file %s: %s\n",
  105.              argv[optind],sys_errlist[errno]);
  106.     } else {
  107.         fp = fopen(Startup,READ_TEXT);
  108.     }
  109.     if(fp != NULLFILE){
  110.         while(fgets(linebuf,BUFSIZ,fp) != NULLCHAR){
  111.             char intmp[BUFSIZ];
  112.             strcpy(intmp,linebuf);
  113.             if(Verbose)
  114.                 tprintf("%s",intmp);
  115.             if(cmdparse(Cmds,linebuf,NULL) != 0){
  116.                 tprintf("input line: %s",intmp);
  117.             }
  118.         }
  119.         fclose(fp);
  120.     }
  121.     cmdmode();
  122.  
  123.     /* Main commutator loop */
  124.     for(;;){
  125.  
  126.         fflush(stdout);
  127.  
  128.         /* Service the clock */
  129.         timerproc();
  130.  
  131.         if(Hopper)
  132.             network();
  133.  
  134.         /* Wait until interrupt, then do it all over again */
  135.         eihalt();
  136.     }
  137. }
  138. /* Enter command mode */
  139. int
  140. cmdmode()
  141. {
  142.     if(Mode != CMD_MODE){
  143.         Mode = CMD_MODE;
  144.         cooked();
  145.         tprintf(Prompt,Hostname);
  146.     }
  147.     return 0;
  148. }
  149. /* Process keyboard characters */
  150. static void
  151. process_char(c)
  152. int c;
  153. {
  154.  
  155.     char *ttybuf;
  156.     int cnt;
  157.  
  158.     if (c == Escape && Escape != 0) {
  159.         ttydriv('\r', &ttybuf);
  160.         Mode = CONV_MODE;
  161.         cmdmode();
  162.         return;
  163.     }
  164.     if ((cnt = ttydriv(c, &ttybuf)) == 0)
  165.         return;
  166.     switch (Mode) {
  167.     case CMD_MODE:
  168.         cmdparse(Cmds, ttybuf, NULL);
  169.         break;
  170.     case CONV_MODE:
  171.         if (Current->parse != NULLVFP)
  172.             (*Current->parse)(ttybuf, cnt);
  173.         break;
  174.     }
  175.     if (Mode == CMD_MODE)
  176.         tprintf(Prompt, Hostname);
  177. }
  178. /* Keyboard input process */
  179. void
  180. keyboard(v)
  181. void *v;
  182. {
  183.  
  184.     char *p;
  185.     char buf[1024];
  186.     int n;
  187.  
  188.     n = read(0, p = buf, sizeof(buf));
  189.     if (n <= 0) dobye(0, (char **) 0, (void * ) 0);
  190.     while (--n >= 0) {
  191.         process_char(uchar(*p++));
  192.         while (Fkey_ptr && *Fkey_ptr)
  193.             process_char(uchar(*Fkey_ptr++));
  194.     }
  195. }
  196. int
  197. dofkey(argc,argv,p)
  198. int argc;
  199. char *argv[];
  200. void *p;
  201. {
  202.     int n;
  203.  
  204.     n = atoi(argv[1]) - 1;
  205.     if (n < 0 || n >= NUM_FKEY) {
  206.         tprintf("key# must be 1..%d\n", NUM_FKEY);
  207.         return 1;
  208.     }
  209.     if (Fkey_table[n])
  210.         free(Fkey_table[n]);
  211.     Fkey_table[n] = strdup(argv[2]);
  212.     return 0;
  213. }
  214. /* Standard commands called from main */
  215. int
  216. dodelete(argc,argv,p)
  217. int argc;
  218. char *argv[];
  219. void *p;
  220. {
  221.     int i;
  222.  
  223.     for(i=1;i < argc; i++){
  224.         if(unlink(argv[i]) == -1){
  225.             tprintf("Can't delete %s: %s\n",
  226.              argv[i],sys_errlist[errno]);
  227.         }
  228.     }
  229.     return 0;
  230. }
  231. int
  232. dorename(argc,argv,p)
  233. int argc;
  234. char *argv[];
  235. void *p;
  236. {
  237.     if(rename(argv[1],argv[2]) == -1)
  238.         tprintf("Can't rename: %s\n",sys_errlist[errno]);
  239.     return 0;
  240. }
  241. int
  242. doexit(argc,argv,p)
  243. int argc;
  244. char *argv[];
  245. void *p;
  246. {
  247.     reset_all();
  248.     shuttrace();
  249.     if(Logfp){
  250.         fclose(Logfp);
  251.         Logfp = NULLFILE;
  252.     }
  253.     iostop();
  254.     exit(0);
  255.     return 0;       /* To satisfy lint */
  256. }
  257. int
  258. dohostname(argc,argv,p)
  259. int argc;
  260. char *argv[];
  261. void *p;
  262. {
  263.     if(argc < 2)
  264.         tprintf("%s\n",Hostname);
  265.     else {
  266. #if 0
  267.         struct iface *ifp;
  268.         char *name;
  269.  
  270.         if((ifp = if_lookup(argv[1])) != NULLIF){
  271.             if((name = resolve_a(ifp->addr, FALSE)) == NULLCHAR){
  272.                 tprintf("Interface address not resolved\n");
  273.                 return 1;
  274.             } else {
  275.                 /* free(argv[1]); */
  276.                 argv[1] = name;
  277.             }
  278.         }
  279. #endif
  280.         if(Hostname != NULLCHAR)
  281.             free(Hostname);
  282.         Hostname = strdup(argv[1]);
  283.     }
  284.     return 0;
  285. }
  286. int
  287. dolog(argc,argv,p)
  288. int argc;
  289. char *argv[];
  290. void *p;
  291. {
  292.     static char *logname;
  293.  
  294.     if(argc < 2){
  295.         if(Logfp)
  296.             tprintf("Logging to %s\n",logname);
  297.         else
  298.             tprintf("Logging off\n");
  299.         return 0;
  300.     }
  301.     if(Logfp){
  302.         fclose(Logfp);
  303.         Logfp = NULLFILE;
  304.         free(logname);
  305.         logname = NULLCHAR;
  306.     }
  307.     if(strcmp(argv[1],"stop") != 0){
  308.         logname = strdup(argv[1]);
  309.         Logfp = fopen(logname,APPEND_TEXT);
  310.     }
  311.     return 0;
  312. }
  313.  
  314. /* Attach an interface
  315.  * Syntax: attach <hw type> <I/O address> <vector> <mode> <label> <bufsize> [<speed>]
  316.  */
  317. int
  318. doattach(argc,argv,p)
  319. int argc;
  320. char *argv[];
  321. void *p;
  322. {
  323.     return subcmd(Attab,argc,argv,p);
  324. }
  325. /* Manipulate I/O device parameters */
  326. int
  327. doparam(argc,argv,p)
  328. int argc;
  329. char *argv[];
  330. void *p;
  331. {
  332.     register struct iface *ifp;
  333.     int param,set;
  334.     int32 val;
  335.  
  336.     if((ifp = if_lookup(argv[1])) == NULLIF){
  337.         tprintf("Interface \"%s\" unknown\n",argv[1]);
  338.         return 1;
  339.     }
  340.     if(ifp->ioctl == NULL){
  341.         tprintf("Not supported\n");
  342.         return 1;
  343.     }
  344.     if(argc < 3){
  345.         for(param=1;param<=16;param++){
  346.             val = (*ifp->ioctl)(ifp,param,FALSE,0L);
  347.             if(val != -1)
  348.                 tprintf("%s: %ld\n",parmname(param),val);
  349.         }
  350.         return 0;
  351.     }
  352.     param = devparam(argv[2]);
  353.     if(param == -1){
  354.         tprintf("Unknown parameter %s\n",argv[2]);
  355.         return 1;
  356.     }
  357.     if(argc < 4){
  358.         set = FALSE;
  359.         val = 0L;
  360.     } else {
  361.         set = TRUE;
  362.         val = atol(argv[3]);
  363.     }
  364.     val = (*ifp->ioctl)(ifp,param,set,val);
  365.     if(val == -1){
  366.         tprintf("Parameter %s not supported\n",argv[2]);
  367.     } else {
  368.         tprintf("%s: %ld\n",parmname(param),val);
  369.     }
  370.     return 0;
  371. }
  372.  
  373. /* Log messages of the form
  374.  * Tue Jan 31 00:00:00 1987 44.64.0.7:1003 open FTP
  375.  */
  376. /*VARARGS2*/
  377. void
  378. log(tcb,fmt,arg1,arg2,arg3,arg4)
  379. struct tcb *tcb;
  380. char *fmt;
  381. int32 arg1,arg2,arg3,arg4;
  382. {
  383.     char *cp;
  384.  
  385.     if(Logfp == NULLFILE)
  386.         return;
  387.     cp = ctime((long *) &Secclock);
  388.     rip(cp);
  389.     if (tcb)
  390.     fprintf(Logfp,"%s %s - ",cp,pinet_tcp(&tcb->conn.remote));
  391.     else
  392.     fprintf(Logfp,"%s - ",cp);
  393.     fprintf(Logfp,fmt,arg1,arg2,arg3,arg4);
  394.     fprintf(Logfp,"\n");
  395.     fflush(Logfp);
  396. #if     (defined(MSDOS) || defined(ATARI_ST))
  397.     /* MS-DOS doesn't really flush files until they're closed */
  398.     fd = fileno(Logfp);
  399.     if((fd = dup(fd)) != -1)
  400.         close(fd);
  401. #endif
  402. }
  403.  
  404. /* Display or set IP interface control flags */
  405. int
  406. domode(argc,argv,p)
  407. int argc;
  408. char *argv[];
  409. void *p;
  410. {
  411.     register struct iface *ifp;
  412.  
  413.     if((ifp = if_lookup(argv[1])) == NULLIF){
  414.         tprintf("Interface \"%s\" unknown\n",argv[1]);
  415.         return 1;
  416.     }
  417.     if(argc < 3){
  418.         tprintf("%s: %s\n",ifp->name,
  419.          (ifp->flags & CONNECT_MODE) ? "VC mode" : "Datagram mode");
  420.         return 0;
  421.     }
  422.     switch(argv[2][0]){
  423.     case 'v':
  424.     case 'c':
  425.     case 'V':
  426.     case 'C':
  427.         ifp->flags = CONNECT_MODE;
  428.         break;
  429.     case 'd':
  430.     case 'D':
  431.         ifp->flags = DATAGRAM_MODE;
  432.         break;
  433.     default:
  434.         tprintf("Usage: %s [vc | datagram]\n",argv[0]);
  435.         return 1;
  436.     }
  437.     return 0;
  438. }
  439.  
  440. #ifndef MSDOS
  441. int
  442. doescape(argc,argv,p)
  443. int argc;
  444. char *argv[];
  445. void *p;
  446. {
  447.     if(argc < 2)
  448.         tprintf("0x%x\n",Escape);
  449.     else
  450.         Escape = *argv[1];
  451.     return 0;
  452. }
  453. #endif  /* MSDOS */
  454. /* Generate system command packet. Synopsis:
  455.  * remote [-p port#] [-k key] [-a hostname] <hostname> reset|exit|kickme
  456.  */
  457. int
  458. doremote(argc,argv,p)
  459. int argc;
  460. char *argv[];
  461. void *p;
  462. {
  463.     struct socket fsock,lsock;
  464.     struct mbuf *bp;
  465.     int c;
  466.     int16 port,len;
  467.     char *key = NULLCHAR;
  468.     int klen;
  469.     int32 addr = 0;
  470.     char *cmd,*host;
  471.  
  472.     port = IPPORT_REMOTE;   /* Set default */
  473.     optind = 1;             /* reinit getopt() */
  474.     while((c = getopt(argc,argv,"a:p:k:s:")) != EOF){
  475.         switch(c){
  476.         case 'a':
  477.             addr = resolve(optarg);
  478.             break;
  479.         case 'p':
  480.             port = atoi(optarg);
  481.             break;
  482.         case 'k':
  483.             key = optarg;
  484.             klen = strlen(key);
  485.             break;
  486.         case 's':
  487.             Rempass = strdup(optarg);
  488.             return 0;       /* Only set local password */
  489.         }
  490.     }
  491.     if(optind > argc - 2){
  492.         tprintf("Insufficient args\n");
  493.         return -1;
  494.     }
  495.     host = argv[optind++];
  496.     cmd = argv[optind];
  497.  
  498.     if (!(fsock.address = resolve(host))) {
  499.         tprintf("Host %s unknown\n",host);
  500.         return 1;
  501.     }
  502.     lsock.address = INADDR_ANY;
  503.     lsock.port = fsock.port = port;
  504.  
  505.     len = 1;
  506.     /* Did the user include a password or kickme target? */
  507.     if(addr != 0)
  508.         len += sizeof(int32);
  509.  
  510.     if(key != NULLCHAR)
  511.         len += klen;
  512.  
  513.     bp = alloc_mbuf(len);
  514.     bp->cnt = 1;
  515.  
  516.     switch(cmd[0]){
  517.     case 'r':
  518.         bp->data[0] = SYS_RESET;
  519.         if(key != NULLCHAR) {
  520.             strncpy(&bp->data[1],key,klen);
  521.             bp->cnt += klen;
  522.         }
  523.         break;
  524.     case 'e':
  525.         bp->data[0] = SYS_EXIT;
  526.         if(key != NULLCHAR) {
  527.             strncpy(&bp->data[1],key,klen);
  528.             bp->cnt += klen;
  529.         }
  530.         break;
  531.     case 'k':
  532.         bp->data[0] = KICK_ME;
  533.         if(addr != 0) {
  534.             put32(&bp->data[1],addr);
  535.             bp->cnt += sizeof(int32);
  536.         }
  537.         break;
  538.     default:
  539.         tprintf("Unknown command %s\n",cmd);
  540.         free_p(bp);
  541.         return 1;
  542.     }
  543.     send_udp(&lsock,&fsock,0,0,bp,0,0,0);
  544.     return 0;
  545. }
  546. /* No-op command */
  547. int
  548. donothing(argc,argv,p)
  549. int argc;
  550. char *argv[];
  551. void *p;
  552. {
  553.     return 0;
  554. }
  555.  
  556. /*---------------------------------------------------------------------------*/
  557.  
  558. int  dosource(argc, argv, p)
  559. int  argc;
  560. char  *argv[];
  561. void *p;
  562. {
  563.  
  564.   FILE * fp;
  565.   char  linebuf[BUFSIZ];
  566.  
  567.   if (!(fp = fopen(argv[1], "r"))) {
  568.     tprintf("cannot open %s\n", argv[1]);
  569.     return 1;
  570.   }
  571.   while (fgets(linebuf, BUFSIZ, fp))
  572.     cmdparse(Cmds, linebuf, NULL);
  573.   fclose(fp);
  574.   Mode = CMD_MODE;
  575.   cooked();
  576.   return 0;
  577. }
  578.  
  579. /*---------------------------------------------------------------------------*/
  580.  
  581. #include <sys/rtprio.h>
  582.  
  583. int  dortprio(argc, argv, p)
  584. int  argc;
  585. char  *argv[];
  586. void *p;
  587. {
  588.   int  tmp;
  589.  
  590.   if (argc < 2) {
  591.     tmp = rtprio(0, RTPRIO_NOCHG);
  592.     if (tmp == RTPRIO_RTOFF)
  593.       tprintf("Rtprio off\n");
  594.     else
  595.       tprintf("Rtprio %d\n", tmp);
  596.   } else {
  597.     tmp = atoi(argv[1]);
  598.     if (tmp <= 0 || tmp > 127) tmp = RTPRIO_RTOFF;
  599.     rtprio(0, tmp);
  600.   }
  601.   return 0;
  602. }
  603.  
  604.